package client.network;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.Socket;

public class ClientSending {

	private Socket m_sending;
	private String m_file_path;
	// private Client m_client;
	
	public ClientSending(Socket sending, Client client, String file_path) {
		m_sending = sending;
		m_file_path = file_path;
		// m_client = client;
	}
	
	/**
	 * Envoie un fichier par blocs au socket sécifié.
	 * @param file_path
	 *    Le chemin du fichier à envoyer.
	 */
	public void send_file_to_server(String file_path, String file_dest)
	{
		// Flux de sortie vers lequel sera écrit notre fichier.
		DataOutputStream _socketOutputStream = null;

		// Flux d'entrée qui servira à lire le fichier.
		FileInputStream _fileInputStream = null;

		try
		{
			// Instanciation d'un objet fichier pour récupérer des infos dessus.
			File _file = new File(file_path);

			// Création d'un nouveau flux de lecture sur le fichier demandé.
			_fileInputStream = new FileInputStream(_file);

			// Récupération du flux de sortie de la socket client.
			_socketOutputStream = new DataOutputStream(m_sending.getOutputStream());

			// Envoi de la taille du fichier qui sera transféré au serveur.
			// Le serveur pourra ainsi arrêter de lire le flux en provenance du socket,
			// et fermer le fichier qu'il aura créé de son côté.
			_socketOutputStream.writeLong(_file.length());
			
			String file_name = "";
			if(file_dest.contains("null")){
				file_name = _file.getName();
			}else{
				file_name = file_dest+"/"+_file.getName();
			}
			// Envoi du nom du fichier
			_socketOutputStream.writeUTF(file_name);

			// Création d'un nouveau buffer de 1024 octets qui servira à stocker les blocs temporaires du fichier.
			byte _buffer[] = new byte[1024];

			// Initialisation du nombre d'octets lus. 
			int nbrOfByte = 0;

			// Lecture du fichier par blocs de maximum 1024 octets.
			nbrOfByte = _fileInputStream.read(_buffer);

			// Tant qu'au moins 1 octet du fichier a été lu puis placé dans le buffer.
			while (nbrOfByte > -1)
			{
				// Ecrire le bloc d'octets sur le flux de sortie du serveur.
				_socketOutputStream.write(_buffer,0,nbrOfByte);

				// Lire un nouveau bloc d'octets
				nbrOfByte = _fileInputStream.read(_buffer);
			}

			// On ferme le flux de lecture du fichier.
			_fileInputStream.close();
			_fileInputStream = null;
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		finally
		{
			try {
				// On force la fermeture du flux de lecture du fichier s'il n'a pas été précédemment fermé.
				if (_fileInputStream != null) _fileInputStream.close();

			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	public void close()
	{
		if (m_sending != null)
		{
			try {
				m_sending.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			m_sending = null;
		}
	}
	
	public String get_file_path(){
		return m_file_path;
	}
	
	public void set_file_path(String file_path){
		m_file_path = file_path;
	}

}
